/*
 Leaflet.draw 1.0.4, a plugin that adds drawing and editing tools to Leaflet powered maps.
 (c) 2012-2017, Jacob Toye, Jon West, Smartrak, Leaflet

 https://github.com/Leaflet/Leaflet.draw
 http://leafletjs.com
 */
!(function (t, e, i) {
  function o(t, e) {
    for (; (t = t.parentElement) && !t.classList.contains(e); );
    return t;
  }
  (L.drawVersion = "1.0.4"),
    (L.Draw = {}),
    (L.drawLocal = {
      draw: {
        toolbar: {
          actions: { title: "Cancel drawing", text: "Cancel" },
          finish: { title: "Finish drawing", text: "Finish" },
          undo: { title: "Delete last point drawn", text: "Delete last point" },
          buttons: {
            polyline: "Draw a polyline",
            polygon: "Draw a polygon",
            rectangle: "Draw a rectangle",
            circle: "Draw a circle",
            marker: "Draw a marker",
            circlemarker: "Draw a circlemarker",
          },
        },
        handlers: {
          circle: {
            tooltip: { start: "Click and drag to draw circle." },
            radius: "Radius",
          },
          circlemarker: {
            tooltip: { start: "Click map to place circle marker." },
          },
          marker: { tooltip: { start: "Click map to place marker." } },
          polygon: {
            tooltip: {
              start: "Click to start drawing shape.",
              cont: "Click to continue drawing shape.",
              end: "Click first point to close this shape.",
            },
          },
          polyline: {
            error: "<strong>Error:</strong> shape edges cannot cross!",
            tooltip: {
              start: "Click to start drawing line.",
              cont: "Click to continue drawing line.",
              end: "Click last point to finish line.",
            },
          },
          rectangle: {
            tooltip: { start: "Click and drag to draw rectangle." },
          },
          simpleshape: { tooltip: { end: "Release mouse to finish drawing." } },
        },
      },
      edit: {
        toolbar: {
          actions: {
            save: { title: "Save changes", text: "Save" },
            cancel: {
              title: "Cancel editing, discards all changes",
              text: "Cancel",
            },
            clearAll: { title: "Clear all layers", text: "Clear All" },
          },
          buttons: {
            edit: "Edit layers",
            editDisabled: "No layers to edit",
            remove: "Delete layers",
            removeDisabled: "No layers to delete",
          },
        },
        handlers: {
          edit: {
            tooltip: {
              text: "Drag handles or markers to edit features.",
              subtext: "Click cancel to undo changes.",
            },
          },
          remove: { tooltip: { text: "Click on a feature to remove." } },
        },
      },
    }),
    (L.Draw.Event = {}),
    (L.Draw.Event.CREATED = "draw:created"),
    (L.Draw.Event.EDITED = "draw:edited"),
    (L.Draw.Event.DELETED = "draw:deleted"),
    (L.Draw.Event.DRAWSTART = "draw:drawstart"),
    (L.Draw.Event.DRAWSTOP = "draw:drawstop"),
    (L.Draw.Event.DRAWVERTEX = "draw:drawvertex"),
    (L.Draw.Event.EDITSTART = "draw:editstart"),
    (L.Draw.Event.EDITMOVE = "draw:editmove"),
    (L.Draw.Event.EDITRESIZE = "draw:editresize"),
    (L.Draw.Event.EDITVERTEX = "draw:editvertex"),
    (L.Draw.Event.EDITSTOP = "draw:editstop"),
    (L.Draw.Event.DELETESTART = "draw:deletestart"),
    (L.Draw.Event.DELETESTOP = "draw:deletestop"),
    (L.Draw.Event.TOOLBAROPENED = "draw:toolbaropened"),
    (L.Draw.Event.TOOLBARCLOSED = "draw:toolbarclosed"),
    (L.Draw.Event.MARKERCONTEXT = "draw:markercontext"),
    (L.Draw = L.Draw || {}),
    (L.Draw.Feature = L.Handler.extend({
      initialize: function (t, e) {
        (this._map = t),
          (this._container = t._container),
          (this._overlayPane = t._panes.overlayPane),
          (this._popupPane = t._panes.popupPane),
          e &&
            e.shapeOptions &&
            (e.shapeOptions = L.Util.extend(
              {},
              this.options.shapeOptions,
              e.shapeOptions
            )),
          L.setOptions(this, e);
        var i = L.version.split(".");
        1 === parseInt(i[0], 10) && parseInt(i[1], 10) >= 2
          ? L.Draw.Feature.include(L.Evented.prototype)
          : L.Draw.Feature.include(L.Mixin.Events);
      },
      enable: function () {
        this._enabled ||
          (L.Handler.prototype.enable.call(this),
          this.fire("enabled", { handler: this.type }),
          this._map.fire(L.Draw.Event.DRAWSTART, { layerType: this.type }));
      },
      disable: function () {
        this._enabled &&
          (L.Handler.prototype.disable.call(this),
          this._map.fire(L.Draw.Event.DRAWSTOP, { layerType: this.type }),
          this.fire("disabled", { handler: this.type }));
      },
      addHooks: function () {
        var t = this._map;
        t &&
          (L.DomUtil.disableTextSelection(),
          t.getContainer().focus(),
          (this._tooltip = new L.Draw.Tooltip(this._map)),
          L.DomEvent.on(this._container, "keyup", this._cancelDrawing, this));
      },
      removeHooks: function () {
        this._map &&
          (L.DomUtil.enableTextSelection(),
          this._tooltip.dispose(),
          (this._tooltip = null),
          L.DomEvent.off(this._container, "keyup", this._cancelDrawing, this));
      },
      setOptions: function (t) {
        L.setOptions(this, t);
      },
      _fireCreatedEvent: function (t) {
        this._map.fire(L.Draw.Event.CREATED, {
          layer: t,
          layerType: this.type,
        });
      },
      _cancelDrawing: function (t) {
        27 === t.keyCode &&
          (this._map.fire("draw:canceled", { layerType: this.type }),
          this.disable());
      },
    })),
    (L.Draw.Polyline = L.Draw.Feature.extend({
      statics: { TYPE: "polyline" },
      Poly: L.Polyline,
      options: {
        allowIntersection: !0,
        repeatMode: !1,
        drawError: { color: "#b00b00", timeout: 2500 },
        icon: new L.DivIcon({
          iconSize: new L.Point(8, 8),
          className: "leaflet-div-icon leaflet-editing-icon",
        }),
        touchIcon: new L.DivIcon({
          iconSize: new L.Point(20, 20),
          className: "leaflet-div-icon leaflet-editing-icon leaflet-touch-icon",
        }),
        guidelineDistance: 20,
        maxGuideLineLength: 4e3,
        shapeOptions: {
          stroke: !0,
          color: "#3388ff",
          weight: 4,
          opacity: 1,
          fill: !1,
          clickable: !0,
        },
        metric: !0,
        feet: !0,
        nautic: !1,
        showLength: !0,
        zIndexOffset: 2e3,
        factor: 1,
        maxPoints: 0,
      },
      initialize: function (t, e) {
        L.Browser.touch && (this.options.icon = this.options.touchIcon),
          (this.options.drawError.message =
            L.drawLocal.draw.handlers.polyline.error),
          e &&
            e.drawError &&
            (e.drawError = L.Util.extend(
              {},
              this.options.drawError,
              e.drawError
            )),
          (this.type = L.Draw.Polyline.TYPE),
          L.Draw.Feature.prototype.initialize.call(this, t, e);
      },
      addHooks: function () {
        L.Draw.Feature.prototype.addHooks.call(this),
          this._map &&
            ((this._markers = []),
            (this._markerGroup = new L.LayerGroup()),
            this._map.addLayer(this._markerGroup),
            (this._poly = new L.Polyline([], this.options.shapeOptions)),
            this._tooltip.updateContent(this._getTooltipText()),
            this._mouseMarker ||
              (this._mouseMarker = L.marker(this._map.getCenter(), {
                icon: L.divIcon({
                  className: "leaflet-mouse-marker",
                  iconAnchor: [20, 20],
                  iconSize: [40, 40],
                }),
                opacity: 0,
                zIndexOffset: this.options.zIndexOffset,
              })),
            this._mouseMarker
              .on("mouseout", this._onMouseOut, this)
              .on("mousemove", this._onMouseMove, this)
              .on("mousedown", this._onMouseDown, this)
              .on("mouseup", this._onMouseUp, this)
              .addTo(this._map),
            this._map
              .on("mouseup", this._onMouseUp, this)
              .on("mousemove", this._onMouseMove, this)
              .on("zoomlevelschange", this._onZoomEnd, this)
              .on("touchstart", this._onTouch, this)
              .on("zoomend", this._onZoomEnd, this));
      },
      removeHooks: function () {
        L.Draw.Feature.prototype.removeHooks.call(this),
          this._clearHideErrorTimeout(),
          this._cleanUpShape(),
          this._map.removeLayer(this._markerGroup),
          delete this._markerGroup,
          delete this._markers,
          this._map.removeLayer(this._poly),
          delete this._poly,
          this._mouseMarker
            .off("mousedown", this._onMouseDown, this)
            .off("mouseout", this._onMouseOut, this)
            .off("mouseup", this._onMouseUp, this)
            .off("mousemove", this._onMouseMove, this),
          this._map.removeLayer(this._mouseMarker),
          delete this._mouseMarker,
          this._clearGuides(),
          this._map
            .off("mouseup", this._onMouseUp, this)
            .off("mousemove", this._onMouseMove, this)
            .off("zoomlevelschange", this._onZoomEnd, this)
            .off("zoomend", this._onZoomEnd, this)
            .off("touchstart", this._onTouch, this)
            .off("click", this._onTouch, this);
      },
      deleteLastVertex: function () {
        if (!(this._markers.length <= 1)) {
          var t = this._markers.pop(),
            e = this._poly,
            i = e.getLatLngs(),
            o = i.splice(-1, 1)[0];
          this._poly.setLatLngs(i),
            this._markerGroup.removeLayer(t),
            e.getLatLngs().length < 2 && this._map.removeLayer(e),
            this._vertexChanged(o, !1);
        }
      },
      addVertex: function (t) {
        if (
          this._markers.length >= 2 &&
          !this.options.allowIntersection &&
          this._poly.newLatLngIntersects(t)
        )
          return void this._showErrorTooltip();
        this._errorShown && this._hideErrorTooltip(),
          this._markers.push(this._createMarker(t)),
          this._poly.addLatLng(t),
          2 === this._poly.getLatLngs().length &&
            this._map.addLayer(this._poly),
          this._vertexChanged(t, !0);
      },
      completeShape: function () {
        this._markers.length <= 1 ||
          !this._shapeIsValid() ||
          (this._fireCreatedEvent(),
          this.disable(),
          this.options.repeatMode && this.enable());
      },
      _finishShape: function () {
        var t = this._poly._defaultShape
            ? this._poly._defaultShape()
            : this._poly.getLatLngs(),
          e = this._poly.newLatLngIntersects(t[t.length - 1]);
        if ((!this.options.allowIntersection && e) || !this._shapeIsValid())
          return void this._showErrorTooltip();
        this._fireCreatedEvent(),
          this.disable(),
          this.options.repeatMode && this.enable();
      },
      _shapeIsValid: function () {
        return !0;
      },
      _onZoomEnd: function () {
        null !== this._markers && this._updateGuide();
      },
      _onMouseMove: function (t) {
        var e = this._map.mouseEventToLayerPoint(t.originalEvent),
          i = this._map.layerPointToLatLng(e);
        (this._currentLatLng = i),
          this._updateTooltip(i),
          this._updateGuide(e),
          this._mouseMarker.setLatLng(i),
          L.DomEvent.preventDefault(t.originalEvent);
      },
      _vertexChanged: function (t, e) {
        this._map.fire(L.Draw.Event.DRAWVERTEX, { layers: this._markerGroup }),
          this._updateFinishHandler(),
          this._updateRunningMeasure(t, e),
          this._clearGuides(),
          this._updateTooltip();
      },
      _onMouseDown: function (t) {
        if (
          !this._clickHandled &&
          !this._touchHandled &&
          !this._disableMarkers
        ) {
          this._onMouseMove(t),
            (this._clickHandled = !0),
            this._disableNewMarkers();
          var e = t.originalEvent,
            i = e.clientX,
            o = e.clientY;
          this._startPoint.call(this, i, o);
        }
      },
      _startPoint: function (t, e) {
        this._mouseDownOrigin = L.point(t, e);
      },
      _onMouseUp: function (t) {
        var e = t.originalEvent,
          i = e.clientX,
          o = e.clientY;
        this._endPoint.call(this, i, o, t), (this._clickHandled = null);
      },
      _endPoint: function (e, i, o) {
        if (this._mouseDownOrigin) {
          var a = L.point(e, i).distanceTo(this._mouseDownOrigin),
            n = this._calculateFinishDistance(o.latlng);
          this.options.maxPoints > 1 &&
          this.options.maxPoints == this._markers.length + 1
            ? (this.addVertex(o.latlng), this._finishShape())
            : n < 10 && L.Browser.touch
            ? this._finishShape()
            : Math.abs(a) < 9 * (t.devicePixelRatio || 1) &&
              this.addVertex(o.latlng),
            this._enableNewMarkers();
        }
        this._mouseDownOrigin = null;
      },
      _onTouch: function (t) {
        var e,
          i,
          o = t.originalEvent;
        !o.touches ||
          !o.touches[0] ||
          this._clickHandled ||
          this._touchHandled ||
          this._disableMarkers ||
          ((e = o.touches[0].clientX),
          (i = o.touches[0].clientY),
          this._disableNewMarkers(),
          (this._touchHandled = !0),
          this._startPoint.call(this, e, i),
          this._endPoint.call(this, e, i, t),
          (this._touchHandled = null)),
          (this._clickHandled = null);
      },
      _onMouseOut: function () {
        this._tooltip && this._tooltip._onMouseOut.call(this._tooltip);
      },
      _calculateFinishDistance: function (t) {
        var e;
        if (this._markers.length > 0) {
          var i;
          if (this.type === L.Draw.Polyline.TYPE)
            i = this._markers[this._markers.length - 1];
          else {
            if (this.type !== L.Draw.Polygon.TYPE) return 1 / 0;
            i = this._markers[0];
          }
          var o = this._map.latLngToContainerPoint(i.getLatLng()),
            a = new L.Marker(t, {
              icon: this.options.icon,
              zIndexOffset: 2 * this.options.zIndexOffset,
            }),
            n = this._map.latLngToContainerPoint(a.getLatLng());
          e = o.distanceTo(n);
        } else e = 1 / 0;
        return e;
      },
      _updateFinishHandler: function () {
        var t = this._markers.length;
        t > 1 && this._markers[t - 1].on("click", this._finishShape, this),
          t > 2 && this._markers[t - 2].off("click", this._finishShape, this);
      },
      _createMarker: function (t) {
        var e = new L.Marker(t, {
          icon: this.options.icon,
          zIndexOffset: 2 * this.options.zIndexOffset,
        });
        return this._markerGroup.addLayer(e), e;
      },
      _updateGuide: function (t) {
        var e = this._markers ? this._markers.length : 0;
        e > 0 &&
          ((t = t || this._map.latLngToLayerPoint(this._currentLatLng)),
          this._clearGuides(),
          this._drawGuide(
            this._map.latLngToLayerPoint(this._markers[e - 1].getLatLng()),
            t
          ));
      },
      _updateTooltip: function (t) {
        var e = this._getTooltipText();
        t && this._tooltip.updatePosition(t),
          this._errorShown || this._tooltip.updateContent(e);
      },
      _drawGuide: function (t, e) {
        var i,
          o,
          a,
          n = Math.floor(
            Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2))
          ),
          s = this.options.guidelineDistance,
          r = this.options.maxGuideLineLength,
          l = n > r ? n - r : s;
        for (
          this._guidesContainer ||
          (this._guidesContainer = L.DomUtil.create(
            "div",
            "leaflet-draw-guides",
            this._overlayPane
          ));
          l < n;
          l += this.options.guidelineDistance
        )
          (i = l / n),
            (o = {
              x: Math.floor(t.x * (1 - i) + i * e.x),
              y: Math.floor(t.y * (1 - i) + i * e.y),
            }),
            (a = L.DomUtil.create(
              "div",
              "leaflet-draw-guide-dash",
              this._guidesContainer
            )),
            (a.style.backgroundColor = this._errorShown
              ? this.options.drawError.color
              : this.options.shapeOptions.color),
            L.DomUtil.setPosition(a, o);
      },
      _updateGuideColor: function (t) {
        if (this._guidesContainer)
          for (
            var e = 0, i = this._guidesContainer.childNodes.length;
            e < i;
            e++
          )
            this._guidesContainer.childNodes[e].style.backgroundColor = t;
      },
      _clearGuides: function () {
        if (this._guidesContainer)
          for (; this._guidesContainer.firstChild; )
            this._guidesContainer.removeChild(this._guidesContainer.firstChild);
      },
      _getTooltipText: function () {
        var t,
          e,
          i = this.options.showLength;
        return (
          0 === this._markers.length
            ? (t = { text: L.drawLocal.draw.handlers.polyline.tooltip.start })
            : ((e = i ? this._getMeasurementString() : ""),
              (t =
                1 === this._markers.length
                  ? {
                      text: L.drawLocal.draw.handlers.polyline.tooltip.cont,
                      subtext: e,
                    }
                  : {
                      text: L.drawLocal.draw.handlers.polyline.tooltip.end,
                      subtext: e,
                    })),
          t
        );
      },
      _updateRunningMeasure: function (t, e) {
        var i,
          o,
          a = this._markers.length;
        1 === this._markers.length
          ? (this._measurementRunningTotal = 0)
          : ((i = a - (e ? 2 : 1)),
            (o = L.GeometryUtil.isVersion07x()
              ? t.distanceTo(this._markers[i].getLatLng()) *
                (this.options.factor || 1)
              : this._map.distance(t, this._markers[i].getLatLng()) *
                (this.options.factor || 1)),
            (this._measurementRunningTotal += o * (e ? 1 : -1)));
      },
      _getMeasurementString: function () {
        var t,
          e = this._currentLatLng,
          i = this._markers[this._markers.length - 1].getLatLng();
        return (
          (t = L.GeometryUtil.isVersion07x()
            ? i && e && e.distanceTo
              ? this._measurementRunningTotal +
                e.distanceTo(i) * (this.options.factor || 1)
              : this._measurementRunningTotal || 0
            : i && e
            ? this._measurementRunningTotal +
              this._map.distance(e, i) * (this.options.factor || 1)
            : this._measurementRunningTotal || 0),
          L.GeometryUtil.readableDistance(
            t,
            this.options.metric,
            this.options.feet,
            this.options.nautic,
            this.options.precision
          )
        );
      },
      _showErrorTooltip: function () {
        (this._errorShown = !0),
          this._tooltip
            .showAsError()
            .updateContent({ text: this.options.drawError.message }),
          this._updateGuideColor(this.options.drawError.color),
          this._poly.setStyle({ color: this.options.drawError.color }),
          this._clearHideErrorTimeout(),
          (this._hideErrorTimeout = setTimeout(
            L.Util.bind(this._hideErrorTooltip, this),
            this.options.drawError.timeout
          ));
      },
      _hideErrorTooltip: function () {
        (this._errorShown = !1),
          this._clearHideErrorTimeout(),
          this._tooltip.removeError().updateContent(this._getTooltipText()),
          this._updateGuideColor(this.options.shapeOptions.color),
          this._poly.setStyle({ color: this.options.shapeOptions.color });
      },
      _clearHideErrorTimeout: function () {
        this._hideErrorTimeout &&
          (clearTimeout(this._hideErrorTimeout),
          (this._hideErrorTimeout = null));
      },
      _disableNewMarkers: function () {
        this._disableMarkers = !0;
      },
      _enableNewMarkers: function () {
        setTimeout(
          function () {
            this._disableMarkers = !1;
          }.bind(this),
          50
        );
      },
      _cleanUpShape: function () {
        this._markers.length > 1 &&
          this._markers[this._markers.length - 1].off(
            "click",
            this._finishShape,
            this
          );
      },
      _fireCreatedEvent: function () {
        var t = new this.Poly(
          this._poly.getLatLngs(),
          this.options.shapeOptions
        );
        L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
      },
    })),
    (L.Draw.Polygon = L.Draw.Polyline.extend({
      statics: { TYPE: "polygon" },
      Poly: L.Polygon,
      options: {
        showArea: !1,
        showLength: !1,
        shapeOptions: {
          stroke: !0,
          color: "#3388ff",
          weight: 4,
          opacity: 1,
          fill: !0,
          fillColor: null,
          fillOpacity: 0.2,
          clickable: !0,
        },
        metric: !0,
        feet: !0,
        nautic: !1,
        precision: {},
      },
      initialize: function (t, e) {
        L.Draw.Polyline.prototype.initialize.call(this, t, e),
          (this.type = L.Draw.Polygon.TYPE);
      },
      _updateFinishHandler: function () {
        var t = this._markers.length;
        1 === t && this._markers[0].on("click", this._finishShape, this),
          t > 2 &&
            (this._markers[t - 1].on("dblclick", this._finishShape, this),
            t > 3 &&
              this._markers[t - 2].off("dblclick", this._finishShape, this));
      },
      _getTooltipText: function () {
        var t, e;
        return (
          0 === this._markers.length
            ? (t = L.drawLocal.draw.handlers.polygon.tooltip.start)
            : this._markers.length < 3
            ? ((t = L.drawLocal.draw.handlers.polygon.tooltip.cont),
              (e = this._getMeasurementString()))
            : ((t = L.drawLocal.draw.handlers.polygon.tooltip.end),
              (e = this._getMeasurementString())),
          { text: t, subtext: e }
        );
      },
      _getMeasurementString: function () {
        var t = this._area,
          e = "";
        return t || this.options.showLength
          ? (this.options.showLength &&
              (e = L.Draw.Polyline.prototype._getMeasurementString.call(this)),
            t &&
              (e +=
                "<br>" +
                L.GeometryUtil.readableArea(
                  t,
                  this.options.metric,
                  this.options.precision
                )),
            e)
          : null;
      },
      _shapeIsValid: function () {
        return this._markers.length >= 3;
      },
      _vertexChanged: function (t, e) {
        var i;
        !this.options.allowIntersection &&
          this.options.showArea &&
          ((i = this._poly.getLatLngs()),
          (this._area = L.GeometryUtil.geodesicArea(i))),
          L.Draw.Polyline.prototype._vertexChanged.call(this, t, e);
      },
      _cleanUpShape: function () {
        var t = this._markers.length;
        t > 0 &&
          (this._markers[0].off("click", this._finishShape, this),
          t > 2 &&
            this._markers[t - 1].off("dblclick", this._finishShape, this));
      },
    })),
    (L.SimpleShape = {}),
    (L.Draw.SimpleShape = L.Draw.Feature.extend({
      options: { repeatMode: !1 },
      initialize: function (t, e) {
        (this._endLabelText =
          L.drawLocal.draw.handlers.simpleshape.tooltip.end),
          L.Draw.Feature.prototype.initialize.call(this, t, e);
      },
      addHooks: function () {
        L.Draw.Feature.prototype.addHooks.call(this),
          this._map &&
            ((this._mapDraggable = this._map.dragging.enabled()),
            this._mapDraggable && this._map.dragging.disable(),
            (this._container.style.cursor = "crosshair"),
            this._tooltip.updateContent({ text: this._initialLabelText }),
            this._map
              .on("mousedown", this._onMouseDown, this)
              .on("mousemove", this._onMouseMove, this)
              .on("touchstart", this._onMouseDown, this)
              .on("touchmove", this._onMouseMove, this),
            e.addEventListener("touchstart", L.DomEvent.preventDefault, {
              passive: !1,
            }));
      },
      removeHooks: function () {
        L.Draw.Feature.prototype.removeHooks.call(this),
          this._map &&
            (this._mapDraggable && this._map.dragging.enable(),
            (this._container.style.cursor = ""),
            this._map
              .off("mousedown", this._onMouseDown, this)
              .off("mousemove", this._onMouseMove, this)
              .off("touchstart", this._onMouseDown, this)
              .off("touchmove", this._onMouseMove, this),
            L.DomEvent.off(e, "mouseup", this._onMouseUp, this),
            L.DomEvent.off(e, "touchend", this._onMouseUp, this),
            e.removeEventListener("touchstart", L.DomEvent.preventDefault),
            this._shape &&
              (this._map.removeLayer(this._shape), delete this._shape)),
          (this._isDrawing = !1);
      },
      _getTooltipText: function () {
        return { text: this._endLabelText };
      },
      _onMouseDown: function (t) {
        (this._isDrawing = !0),
          (this._startLatLng = t.latlng),
          L.DomEvent.on(e, "mouseup", this._onMouseUp, this)
            .on(e, "touchend", this._onMouseUp, this)
            .preventDefault(t.originalEvent);
      },
      _onMouseMove: function (t) {
        var e = t.latlng;
        this._tooltip.updatePosition(e),
          this._isDrawing &&
            (this._tooltip.updateContent(this._getTooltipText()),
            this._drawShape(e));
      },
      _onMouseUp: function () {
        this._shape && this._fireCreatedEvent(),
          this.disable(),
          this.options.repeatMode && this.enable();
      },
    })),
    (L.Draw.Rectangle = L.Draw.SimpleShape.extend({
      statics: { TYPE: "rectangle" },
      options: {
        shapeOptions: {
          stroke: !0,
          color: "#3388ff",
          weight: 4,
          opacity: 1,
          fill: !0,
          fillColor: null,
          fillOpacity: 0.2,
          clickable: !0,
        },
        showArea: !0,
        metric: !0,
      },
      initialize: function (t, e) {
        (this.type = L.Draw.Rectangle.TYPE),
          (this._initialLabelText =
            L.drawLocal.draw.handlers.rectangle.tooltip.start),
          L.Draw.SimpleShape.prototype.initialize.call(this, t, e);
      },
      disable: function () {
        this._enabled &&
          ((this._isCurrentlyTwoClickDrawing = !1),
          L.Draw.SimpleShape.prototype.disable.call(this));
      },
      _onMouseUp: function (t) {
        if (!this._shape && !this._isCurrentlyTwoClickDrawing)
          return void (this._isCurrentlyTwoClickDrawing = !0);
        (this._isCurrentlyTwoClickDrawing && !o(t.target, "leaflet-pane")) ||
          L.Draw.SimpleShape.prototype._onMouseUp.call(this);
      },
      _drawShape: function (t) {
        this._shape
          ? this._shape.setBounds(new L.LatLngBounds(this._startLatLng, t))
          : ((this._shape = new L.Rectangle(
              new L.LatLngBounds(this._startLatLng, t),
              this.options.shapeOptions
            )),
            this._map.addLayer(this._shape));
      },
      _fireCreatedEvent: function () {
        var t = new L.Rectangle(
          this._shape.getBounds(),
          this.options.shapeOptions
        );
        L.Draw.SimpleShape.prototype._fireCreatedEvent.call(this, t);
      },
      _getTooltipText: function () {
        var t,
          e,
          i,
          o = L.Draw.SimpleShape.prototype._getTooltipText.call(this),
          a = this._shape,
          n = this.options.showArea;
        return (
          a &&
            ((t = this._shape._defaultShape
              ? this._shape._defaultShape()
              : this._shape.getLatLngs()),
            (e = L.GeometryUtil.geodesicArea(t)),
            (i = n ? L.GeometryUtil.readableArea(e, this.options.metric) : "")),
          { text: o.text, subtext: i }
        );
      },
    })),
    (L.Draw.Marker = L.Draw.Feature.extend({
      statics: { TYPE: "marker" },
      options: {
        icon: new L.Icon.Default(),
        repeatMode: !1,
        zIndexOffset: 2e3,
      },
      initialize: function (t, e) {
        (this.type = L.Draw.Marker.TYPE),
          (this._initialLabelText =
            L.drawLocal.draw.handlers.marker.tooltip.start),
          L.Draw.Feature.prototype.initialize.call(this, t, e);
      },
      addHooks: function () {
        L.Draw.Feature.prototype.addHooks.call(this),
          this._map &&
            (this._tooltip.updateContent({ text: this._initialLabelText }),
            this._mouseMarker ||
              (this._mouseMarker = L.marker(this._map.getCenter(), {
                icon: L.divIcon({
                  className: "leaflet-mouse-marker",
                  iconAnchor: [20, 20],
                  iconSize: [40, 40],
                }),
                opacity: 0,
                zIndexOffset: this.options.zIndexOffset,
              })),
            this._mouseMarker.on("click", this._onClick, this).addTo(this._map),
            this._map.on("mousemove", this._onMouseMove, this),
            this._map.on("click", this._onTouch, this));
      },
      removeHooks: function () {
        L.Draw.Feature.prototype.removeHooks.call(this),
          this._map &&
            (this._map
              .off("click", this._onClick, this)
              .off("click", this._onTouch, this),
            this._marker &&
              (this._marker.off("click", this._onClick, this),
              this._map.removeLayer(this._marker),
              delete this._marker),
            this._mouseMarker.off("click", this._onClick, this),
            this._map.removeLayer(this._mouseMarker),
            delete this._mouseMarker,
            this._map.off("mousemove", this._onMouseMove, this));
      },
      _onMouseMove: function (t) {
        var e = t.latlng;
        this._tooltip.updatePosition(e),
          this._mouseMarker.setLatLng(e),
          this._marker
            ? ((e = this._mouseMarker.getLatLng()), this._marker.setLatLng(e))
            : ((this._marker = this._createMarker(e)),
              this._marker.on("click", this._onClick, this),
              this._map
                .on("click", this._onClick, this)
                .addLayer(this._marker));
      },
      _createMarker: function (t) {
        return new L.Marker(t, {
          icon: this.options.icon,
          zIndexOffset: this.options.zIndexOffset,
        });
      },
      _onClick: function () {
        this._fireCreatedEvent(),
          this.disable(),
          this.options.repeatMode && this.enable();
      },
      _onTouch: function (t) {
        this._onMouseMove(t), this._onClick();
      },
      _fireCreatedEvent: function () {
        var t = new L.Marker.Touch(this._marker.getLatLng(), {
          icon: this.options.icon,
        });
        L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
      },
    })),
    (L.Draw.CircleMarker = L.Draw.Marker.extend({
      statics: { TYPE: "circlemarker" },
      options: {
        stroke: !0,
        color: "#3388ff",
        weight: 4,
        opacity: 1,
        fill: !0,
        fillColor: null,
        fillOpacity: 0.2,
        clickable: !0,
        zIndexOffset: 2e3,
      },
      initialize: function (t, e) {
        (this.type = L.Draw.CircleMarker.TYPE),
          (this._initialLabelText =
            L.drawLocal.draw.handlers.circlemarker.tooltip.start),
          L.Draw.Feature.prototype.initialize.call(this, t, e);
      },
      _fireCreatedEvent: function () {
        var t = new L.CircleMarker(this._marker.getLatLng(), this.options);
        L.Draw.Feature.prototype._fireCreatedEvent.call(this, t);
      },
      _createMarker: function (t) {
        return new L.CircleMarker(t, this.options);
      },
    })),
    (L.Draw.Circle = L.Draw.SimpleShape.extend({
      statics: { TYPE: "circle" },
      options: {
        shapeOptions: {
          stroke: !0,
          color: "#3388ff",
          weight: 4,
          opacity: 1,
          fill: !0,
          fillColor: null,
          fillOpacity: 0.2,
          clickable: !0,
        },
        showRadius: !0,
        metric: !0,
        feet: !0,
        nautic: !1,
      },
      initialize: function (t, e) {
        (this.type = L.Draw.Circle.TYPE),
          (this._initialLabelText =
            L.drawLocal.draw.handlers.circle.tooltip.start),
          L.Draw.SimpleShape.prototype.initialize.call(this, t, e);
      },
      _drawShape: function (t) {
        if (L.GeometryUtil.isVersion07x())
          var e = this._startLatLng.distanceTo(t);
        else var e = this._map.distance(this._startLatLng, t);
        this._shape
          ? this._shape.setRadius(e)
          : ((this._shape = new L.Circle(
              this._startLatLng,
              e,
              this.options.shapeOptions
            )),
            this._map.addLayer(this._shape));
      },
      _fireCreatedEvent: function () {
        var t = new L.Circle(
          this._startLatLng,
          this._shape.getRadius(),
          this.options.shapeOptions
        );
        L.Draw.SimpleShape.prototype._fireCreatedEvent.call(this, t);
      },
      _onMouseMove: function (t) {
        var e,
          i = t.latlng,
          o = this.options.showRadius,
          a = this.options.metric;
        if ((this._tooltip.updatePosition(i), this._isDrawing)) {
          this._drawShape(i), (e = this._shape.getRadius().toFixed(1));
          var n = "";
          o &&
            (n =
              L.drawLocal.draw.handlers.circle.radius +
              ": " +
              L.GeometryUtil.readableDistance(
                e,
                a,
                this.options.feet,
                this.options.nautic
              )),
            this._tooltip.updateContent({
              text: this._endLabelText,
              subtext: n,
            });
        }
      },
    })),
    (L.Edit = L.Edit || {}),
    (L.Edit.Marker = L.Handler.extend({
      initialize: function (t, e) {
        (this._marker = t), L.setOptions(this, e);
      },
      addHooks: function () {
        var t = this._marker;
        t.dragging.enable(),
          t.on("dragend", this._onDragEnd, t),
          this._toggleMarkerHighlight();
      },
      removeHooks: function () {
        var t = this._marker;
        t.dragging.disable(),
          t.off("dragend", this._onDragEnd, t),
          this._toggleMarkerHighlight();
      },
      _onDragEnd: function (t) {
        var e = t.target;
        (e.edited = !0), this._map.fire(L.Draw.Event.EDITMOVE, { layer: e });
      },
      _toggleMarkerHighlight: function () {
        var t = this._marker._icon;
        t &&
          ((t.style.display = "none"),
          L.DomUtil.hasClass(t, "leaflet-edit-marker-selected")
            ? (L.DomUtil.removeClass(t, "leaflet-edit-marker-selected"),
              this._offsetMarker(t, -4))
            : (L.DomUtil.addClass(t, "leaflet-edit-marker-selected"),
              this._offsetMarker(t, 4)),
          (t.style.display = ""));
      },
      _offsetMarker: function (t, e) {
        var i = parseInt(t.style.marginTop, 10) - e,
          o = parseInt(t.style.marginLeft, 10) - e;
        (t.style.marginTop = i + "px"), (t.style.marginLeft = o + "px");
      },
    })),
    L.Marker.addInitHook(function () {
      L.Edit.Marker &&
        ((this.editing = new L.Edit.Marker(this)),
        this.options.editable && this.editing.enable());
    }),
    (L.Edit = L.Edit || {}),
    (L.Edit.Poly = L.Handler.extend({
      initialize: function (t) {
        (this.latlngs = [t._latlngs]),
          t._holes && (this.latlngs = this.latlngs.concat(t._holes)),
          (this._poly = t),
          this._poly.on("revert-edited", this._updateLatLngs, this);
      },
      _defaultShape: function () {
        return L.Polyline._flat
          ? L.Polyline._flat(this._poly._latlngs)
            ? this._poly._latlngs
            : this._poly._latlngs[0]
          : this._poly._latlngs;
      },
      _eachVertexHandler: function (t) {
        for (var e = 0; e < this._verticesHandlers.length; e++)
          t(this._verticesHandlers[e]);
      },
      addHooks: function () {
        this._initHandlers(),
          this._eachVertexHandler(function (t) {
            t.addHooks();
          });
      },
      removeHooks: function () {
        this._eachVertexHandler(function (t) {
          t.removeHooks();
        });
      },
      updateMarkers: function () {
        this._eachVertexHandler(function (t) {
          t.updateMarkers();
        });
      },
      _initHandlers: function () {
        this._verticesHandlers = [];
        for (var t = 0; t < this.latlngs.length; t++)
          this._verticesHandlers.push(
            new L.Edit.PolyVerticesEdit(
              this._poly,
              this.latlngs[t],
              this._poly.options.poly
            )
          );
      },
      _updateLatLngs: function (t) {
        (this.latlngs = [t.layer._latlngs]),
          t.layer._holes &&
            (this.latlngs = this.latlngs.concat(t.layer._holes));
      },
    })),
    (L.Edit.PolyVerticesEdit = L.Handler.extend({
      options: {
        icon: new L.DivIcon({
          iconSize: new L.Point(8, 8),
          className: "leaflet-div-icon leaflet-editing-icon",
        }),
        touchIcon: new L.DivIcon({
          iconSize: new L.Point(20, 20),
          className: "leaflet-div-icon leaflet-editing-icon leaflet-touch-icon",
        }),
        drawError: { color: "#b00b00", timeout: 1e3 },
      },
      initialize: function (t, e, i) {
        L.Browser.touch && (this.options.icon = this.options.touchIcon),
          (this._poly = t),
          i &&
            i.drawError &&
            (i.drawError = L.Util.extend(
              {},
              this.options.drawError,
              i.drawError
            )),
          (this._latlngs = e),
          L.setOptions(this, i);
      },
      _defaultShape: function () {
        return L.Polyline._flat
          ? L.Polyline._flat(this._latlngs)
            ? this._latlngs
            : this._latlngs[0]
          : this._latlngs;
      },
      addHooks: function () {
        var t = this._poly,
          e = t._path;
        t instanceof L.Polygon ||
          ((t.options.fill = !1),
          t.options.editing && (t.options.editing.fill = !1)),
          e &&
            t.options.editing &&
            t.options.editing.className &&
            (t.options.original.className &&
              t.options.original.className.split(" ").forEach(function (t) {
                L.DomUtil.removeClass(e, t);
              }),
            t.options.editing.className.split(" ").forEach(function (t) {
              L.DomUtil.addClass(e, t);
            })),
          t.setStyle(t.options.editing),
          this._poly._map &&
            ((this._map = this._poly._map),
            this._markerGroup || this._initMarkers(),
            this._poly._map.addLayer(this._markerGroup));
      },
      removeHooks: function () {
        var t = this._poly,
          e = t._path;
        e &&
          t.options.editing &&
          t.options.editing.className &&
          (t.options.editing.className.split(" ").forEach(function (t) {
            L.DomUtil.removeClass(e, t);
          }),
          t.options.original.className &&
            t.options.original.className.split(" ").forEach(function (t) {
              L.DomUtil.addClass(e, t);
            })),
          t.setStyle(t.options.original),
          t._map &&
            (t._map.removeLayer(this._markerGroup),
            delete this._markerGroup,
            delete this._markers);
      },
      updateMarkers: function () {
        this._markerGroup.clearLayers(), this._initMarkers();
      },
      _initMarkers: function () {
        this._markerGroup || (this._markerGroup = new L.LayerGroup()),
          (this._markers = []);
        var t,
          e,
          i,
          o,
          a = this._defaultShape();
        for (t = 0, i = a.length; t < i; t++)
          (o = this._createMarker(a[t], t)),
            o.on("click", this._onMarkerClick, this),
            o.on("contextmenu", this._onContextMenu, this),
            this._markers.push(o);
        var n, s;
        for (t = 0, e = i - 1; t < i; e = t++)
          (0 !== t || (L.Polygon && this._poly instanceof L.Polygon)) &&
            ((n = this._markers[e]),
            (s = this._markers[t]),
            this._createMiddleMarker(n, s),
            this._updatePrevNext(n, s));
      },
      _createMarker: function (t, e) {
        var i = new L.Marker.Touch(t, {
          draggable: !0,
          icon: this.options.icon,
        });
        return (
          (i._origLatLng = t),
          (i._index = e),
          i
            .on("dragstart", this._onMarkerDragStart, this)
            .on("drag", this._onMarkerDrag, this)
            .on("dragend", this._fireEdit, this)
            .on("touchmove", this._onTouchMove, this)
            .on("touchend", this._fireEdit, this)
            .on("MSPointerMove", this._onTouchMove, this)
            .on("MSPointerUp", this._fireEdit, this),
          this._markerGroup.addLayer(i),
          i
        );
      },
      _onMarkerDragStart: function () {
        this._poly.fire("editstart");
      },
      _spliceLatLngs: function () {
        var t = this._defaultShape(),
          e = [].splice.apply(t, arguments);
        return this._poly._convertLatLngs(t, !0), this._poly.redraw(), e;
      },
      _removeMarker: function (t) {
        var e = t._index;
        this._markerGroup.removeLayer(t),
          this._markers.splice(e, 1),
          this._spliceLatLngs(e, 1),
          this._updateIndexes(e, -1),
          t
            .off("dragstart", this._onMarkerDragStart, this)
            .off("drag", this._onMarkerDrag, this)
            .off("dragend", this._fireEdit, this)
            .off("touchmove", this._onMarkerDrag, this)
            .off("touchend", this._fireEdit, this)
            .off("click", this._onMarkerClick, this)
            .off("MSPointerMove", this._onTouchMove, this)
            .off("MSPointerUp", this._fireEdit, this);
      },
      _fireEdit: function () {
        (this._poly.edited = !0),
          this._poly.fire("edit"),
          this._poly._map.fire(L.Draw.Event.EDITVERTEX, {
            layers: this._markerGroup,
            poly: this._poly,
          });
      },
      _onMarkerDrag: function (t) {
        var e = t.target,
          i = this._poly,
          o = L.LatLngUtil.cloneLatLng(e._origLatLng);
        if ((L.extend(e._origLatLng, e._latlng), i.options.poly)) {
          var a = i._map._editTooltip;
          if (!i.options.poly.allowIntersection && i.intersects()) {
            L.extend(e._origLatLng, o), e.setLatLng(o);
            var n = i.options.color;
            i.setStyle({ color: this.options.drawError.color }),
              a &&
                a.updateContent({
                  text: L.drawLocal.draw.handlers.polyline.error,
                }),
              setTimeout(function () {
                i.setStyle({ color: n }),
                  a &&
                    a.updateContent({
                      text: L.drawLocal.edit.handlers.edit.tooltip.text,
                      subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext,
                    });
              }, 1e3);
          }
        }
        e._middleLeft &&
          e._middleLeft.setLatLng(this._getMiddleLatLng(e._prev, e)),
          e._middleRight &&
            e._middleRight.setLatLng(this._getMiddleLatLng(e, e._next)),
          (this._poly._bounds._southWest = L.latLng(1 / 0, 1 / 0)),
          (this._poly._bounds._northEast = L.latLng(-1 / 0, -1 / 0));
        var s = this._poly.getLatLngs();
        this._poly._convertLatLngs(s, !0),
          this._poly.redraw(),
          this._poly.fire("editdrag");
      },
      _onMarkerClick: function (t) {
        var e = L.Polygon && this._poly instanceof L.Polygon ? 4 : 3,
          i = t.target;
        this._defaultShape().length < e ||
          (this._removeMarker(i),
          this._updatePrevNext(i._prev, i._next),
          i._middleLeft && this._markerGroup.removeLayer(i._middleLeft),
          i._middleRight && this._markerGroup.removeLayer(i._middleRight),
          i._prev && i._next
            ? this._createMiddleMarker(i._prev, i._next)
            : i._prev
            ? i._next || (i._prev._middleRight = null)
            : (i._next._middleLeft = null),
          this._fireEdit());
      },
      _onContextMenu: function (t) {
        var e = t.target;
        this._poly;
        this._poly._map.fire(L.Draw.Event.MARKERCONTEXT, {
          marker: e,
          layers: this._markerGroup,
          poly: this._poly,
        }),
          L.DomEvent.stopPropagation;
      },
      _onTouchMove: function (t) {
        var e = this._map.mouseEventToLayerPoint(t.originalEvent.touches[0]),
          i = this._map.layerPointToLatLng(e),
          o = t.target;
        L.extend(o._origLatLng, i),
          o._middleLeft &&
            o._middleLeft.setLatLng(this._getMiddleLatLng(o._prev, o)),
          o._middleRight &&
            o._middleRight.setLatLng(this._getMiddleLatLng(o, o._next)),
          this._poly.redraw(),
          this.updateMarkers();
      },
      _updateIndexes: function (t, e) {
        this._markerGroup.eachLayer(function (i) {
          i._index > t && (i._index += e);
        });
      },
      _createMiddleMarker: function (t, e) {
        var i,
          o,
          a,
          n = this._getMiddleLatLng(t, e),
          s = this._createMarker(n);
        s.setOpacity(0.6),
          (t._middleRight = e._middleLeft = s),
          (o = function () {
            s.off("touchmove", o, this);
            var a = e._index;
            (s._index = a),
              s.off("click", i, this).on("click", this._onMarkerClick, this),
              (n.lat = s.getLatLng().lat),
              (n.lng = s.getLatLng().lng),
              this._spliceLatLngs(a, 0, n),
              this._markers.splice(a, 0, s),
              s.setOpacity(1),
              this._updateIndexes(a, 1),
              e._index++,
              this._updatePrevNext(t, s),
              this._updatePrevNext(s, e),
              this._poly.fire("editstart");
          }),
          (a = function () {
            s.off("dragstart", o, this),
              s.off("dragend", a, this),
              s.off("touchmove", o, this),
              this._createMiddleMarker(t, s),
              this._createMiddleMarker(s, e);
          }),
          (i = function () {
            o.call(this), a.call(this), this._fireEdit();
          }),
          s
            .on("click", i, this)
            .on("dragstart", o, this)
            .on("dragend", a, this)
            .on("touchmove", o, this),
          this._markerGroup.addLayer(s);
      },
      _updatePrevNext: function (t, e) {
        t && (t._next = e), e && (e._prev = t);
      },
      _getMiddleLatLng: function (t, e) {
        var i = this._poly._map,
          o = i.project(t.getLatLng()),
          a = i.project(e.getLatLng());
        return i.unproject(o._add(a)._divideBy(2));
      },
    })),
    L.Polyline.addInitHook(function () {
      this.editing ||
        (L.Edit.Poly &&
          ((this.editing = new L.Edit.Poly(this)),
          this.options.editable && this.editing.enable()),
        this.on("add", function () {
          this.editing && this.editing.enabled() && this.editing.addHooks();
        }),
        this.on("remove", function () {
          this.editing && this.editing.enabled() && this.editing.removeHooks();
        }));
    }),
    (L.Edit = L.Edit || {}),
    (L.Edit.SimpleShape = L.Handler.extend({
      options: {
        moveIcon: new L.DivIcon({
          iconSize: new L.Point(8, 8),
          className: "leaflet-div-icon leaflet-editing-icon leaflet-edit-move",
        }),
        resizeIcon: new L.DivIcon({
          iconSize: new L.Point(8, 8),
          className:
            "leaflet-div-icon leaflet-editing-icon leaflet-edit-resize",
        }),
        touchMoveIcon: new L.DivIcon({
          iconSize: new L.Point(20, 20),
          className:
            "leaflet-div-icon leaflet-editing-icon leaflet-edit-move leaflet-touch-icon",
        }),
        touchResizeIcon: new L.DivIcon({
          iconSize: new L.Point(20, 20),
          className:
            "leaflet-div-icon leaflet-editing-icon leaflet-edit-resize leaflet-touch-icon",
        }),
      },
      initialize: function (t, e) {
        L.Browser.touch &&
          ((this.options.moveIcon = this.options.touchMoveIcon),
          (this.options.resizeIcon = this.options.touchResizeIcon)),
          (this._shape = t),
          L.Util.setOptions(this, e);
      },
      addHooks: function () {
        var t = this._shape;
        this._shape._map &&
          ((this._map = this._shape._map),
          t.setStyle(t.options.editing),
          t._map &&
            ((this._map = t._map),
            this._markerGroup || this._initMarkers(),
            this._map.addLayer(this._markerGroup)));
      },
      removeHooks: function () {
        var t = this._shape;
        if ((t.setStyle(t.options.original), t._map)) {
          this._unbindMarker(this._moveMarker);
          for (var e = 0, i = this._resizeMarkers.length; e < i; e++)
            this._unbindMarker(this._resizeMarkers[e]);
          (this._resizeMarkers = null),
            this._map.removeLayer(this._markerGroup),
            delete this._markerGroup;
        }
        this._map = null;
      },
      updateMarkers: function () {
        this._markerGroup.clearLayers(), this._initMarkers();
      },
      _initMarkers: function () {
        this._markerGroup || (this._markerGroup = new L.LayerGroup()),
          this._createMoveMarker(),
          this._createResizeMarker();
      },
      _createMoveMarker: function () {},
      _createResizeMarker: function () {},
      _createMarker: function (t, e) {
        var i = new L.Marker.Touch(t, {
          draggable: !0,
          icon: e,
          zIndexOffset: 10,
        });
        return this._bindMarker(i), this._markerGroup.addLayer(i), i;
      },
      _bindMarker: function (t) {
        t.on("dragstart", this._onMarkerDragStart, this)
          .on("drag", this._onMarkerDrag, this)
          .on("dragend", this._onMarkerDragEnd, this)
          .on("touchstart", this._onTouchStart, this)
          .on("touchmove", this._onTouchMove, this)
          .on("MSPointerMove", this._onTouchMove, this)
          .on("touchend", this._onTouchEnd, this)
          .on("MSPointerUp", this._onTouchEnd, this);
      },
      _unbindMarker: function (t) {
        t.off("dragstart", this._onMarkerDragStart, this)
          .off("drag", this._onMarkerDrag, this)
          .off("dragend", this._onMarkerDragEnd, this)
          .off("touchstart", this._onTouchStart, this)
          .off("touchmove", this._onTouchMove, this)
          .off("MSPointerMove", this._onTouchMove, this)
          .off("touchend", this._onTouchEnd, this)
          .off("MSPointerUp", this._onTouchEnd, this);
      },
      _onMarkerDragStart: function (t) {
        t.target.setOpacity(0), this._shape.fire("editstart");
      },
      _fireEdit: function () {
        (this._shape.edited = !0), this._shape.fire("edit");
      },
      _onMarkerDrag: function (t) {
        var e = t.target,
          i = e.getLatLng();
        e === this._moveMarker ? this._move(i) : this._resize(i),
          this._shape.redraw(),
          this._shape.fire("editdrag");
      },
      _onMarkerDragEnd: function (t) {
        t.target.setOpacity(1), this._fireEdit();
      },
      _onTouchStart: function (t) {
        if (
          (L.Edit.SimpleShape.prototype._onMarkerDragStart.call(this, t),
          "function" == typeof this._getCorners)
        ) {
          var e = this._getCorners(),
            i = t.target,
            o = i._cornerIndex;
          i.setOpacity(0),
            (this._oppositeCorner = e[(o + 2) % 4]),
            this._toggleCornerMarkers(0, o);
        }
        this._shape.fire("editstart");
      },
      _onTouchMove: function (t) {
        var e = this._map.mouseEventToLayerPoint(t.originalEvent.touches[0]),
          i = this._map.layerPointToLatLng(e);
        return (
          t.target === this._moveMarker ? this._move(i) : this._resize(i),
          this._shape.redraw(),
          !1
        );
      },
      _onTouchEnd: function (t) {
        t.target.setOpacity(1), this.updateMarkers(), this._fireEdit();
      },
      _move: function () {},
      _resize: function () {},
    })),
    (L.Edit = L.Edit || {}),
    (L.Edit.Rectangle = L.Edit.SimpleShape.extend({
      _createMoveMarker: function () {
        var t = this._shape.getBounds(),
          e = t.getCenter();
        this._moveMarker = this._createMarker(e, this.options.moveIcon);
      },
      _createResizeMarker: function () {
        var t = this._getCorners();
        this._resizeMarkers = [];
        for (var e = 0, i = t.length; e < i; e++)
          this._resizeMarkers.push(
            this._createMarker(t[e], this.options.resizeIcon)
          ),
            (this._resizeMarkers[e]._cornerIndex = e);
      },
      _onMarkerDragStart: function (t) {
        L.Edit.SimpleShape.prototype._onMarkerDragStart.call(this, t);
        var e = this._getCorners(),
          i = t.target,
          o = i._cornerIndex;
        (this._oppositeCorner = e[(o + 2) % 4]),
          this._toggleCornerMarkers(0, o);
      },
      _onMarkerDragEnd: function (t) {
        var e,
          i,
          o = t.target;
        o === this._moveMarker &&
          ((e = this._shape.getBounds()), (i = e.getCenter()), o.setLatLng(i)),
          this._toggleCornerMarkers(1),
          this._repositionCornerMarkers(),
          L.Edit.SimpleShape.prototype._onMarkerDragEnd.call(this, t);
      },
      _move: function (t) {
        for (
          var e,
            i = this._shape._defaultShape
              ? this._shape._defaultShape()
              : this._shape.getLatLngs(),
            o = this._shape.getBounds(),
            a = o.getCenter(),
            n = [],
            s = 0,
            r = i.length;
          s < r;
          s++
        )
          (e = [i[s].lat - a.lat, i[s].lng - a.lng]),
            n.push([t.lat + e[0], t.lng + e[1]]);
        this._shape.setLatLngs(n),
          this._repositionCornerMarkers(),
          this._map.fire(L.Draw.Event.EDITMOVE, { layer: this._shape });
      },
      _resize: function (t) {
        var e;
        this._shape.setBounds(L.latLngBounds(t, this._oppositeCorner)),
          (e = this._shape.getBounds()),
          this._moveMarker.setLatLng(e.getCenter()),
          this._map.fire(L.Draw.Event.EDITRESIZE, { layer: this._shape });
      },
      _getCorners: function () {
        var t = this._shape.getBounds();
        return [
          t.getNorthWest(),
          t.getNorthEast(),
          t.getSouthEast(),
          t.getSouthWest(),
        ];
      },
      _toggleCornerMarkers: function (t) {
        for (var e = 0, i = this._resizeMarkers.length; e < i; e++)
          this._resizeMarkers[e].setOpacity(t);
      },
      _repositionCornerMarkers: function () {
        for (
          var t = this._getCorners(), e = 0, i = this._resizeMarkers.length;
          e < i;
          e++
        )
          this._resizeMarkers[e].setLatLng(t[e]);
      },
    })),
    L.Rectangle.addInitHook(function () {
      L.Edit.Rectangle &&
        ((this.editing = new L.Edit.Rectangle(this)),
        this.options.editable && this.editing.enable());
    }),
    (L.Edit = L.Edit || {}),
    (L.Edit.CircleMarker = L.Edit.SimpleShape.extend({
      _createMoveMarker: function () {
        var t = this._shape.getLatLng();
        this._moveMarker = this._createMarker(t, this.options.moveIcon);
      },
      _createResizeMarker: function () {
        this._resizeMarkers = [];
      },
      _move: function (t) {
        if (this._resizeMarkers.length) {
          var e = this._getResizeMarkerPoint(t);
          this._resizeMarkers[0].setLatLng(e);
        }
        this._shape.setLatLng(t),
          this._map.fire(L.Draw.Event.EDITMOVE, { layer: this._shape });
      },
    })),
    L.CircleMarker.addInitHook(function () {
      L.Edit.CircleMarker &&
        ((this.editing = new L.Edit.CircleMarker(this)),
        this.options.editable && this.editing.enable()),
        this.on("add", function () {
          this.editing && this.editing.enabled() && this.editing.addHooks();
        }),
        this.on("remove", function () {
          this.editing && this.editing.enabled() && this.editing.removeHooks();
        });
    }),
    (L.Edit = L.Edit || {}),
    (L.Edit.Circle = L.Edit.CircleMarker.extend({
      _createResizeMarker: function () {
        var t = this._shape.getLatLng(),
          e = this._getResizeMarkerPoint(t);
        (this._resizeMarkers = []),
          this._resizeMarkers.push(
            this._createMarker(e, this.options.resizeIcon)
          );
      },
      _getResizeMarkerPoint: function (t) {
        var e = this._shape._radius * Math.cos(Math.PI / 4),
          i = this._map.project(t);
        return this._map.unproject([i.x + e, i.y - e]);
      },
      _resize: function (t) {
        var e = this._moveMarker.getLatLng();
        L.GeometryUtil.isVersion07x()
          ? (radius = e.distanceTo(t))
          : (radius = this._map.distance(e, t)),
          this._shape.setRadius(radius),
          this._map.editTooltip &&
            this._map._editTooltip.updateContent({
              text:
                L.drawLocal.edit.handlers.edit.tooltip.subtext +
                "<br />" +
                L.drawLocal.edit.handlers.edit.tooltip.text,
              subtext:
                L.drawLocal.draw.handlers.circle.radius +
                ": " +
                L.GeometryUtil.readableDistance(
                  radius,
                  !0,
                  this.options.feet,
                  this.options.nautic
                ),
            }),
          this._shape.setRadius(radius),
          this._map.fire(L.Draw.Event.EDITRESIZE, { layer: this._shape });
      },
    })),
    L.Circle.addInitHook(function () {
      L.Edit.Circle &&
        ((this.editing = new L.Edit.Circle(this)),
        this.options.editable && this.editing.enable());
    }),
    L.Map.mergeOptions({ touchExtend: !0 }),
    (L.Map.TouchExtend = L.Handler.extend({
      initialize: function (t) {
        (this._map = t),
          (this._container = t._container),
          (this._pane = t._panes.overlayPane);
      },
      addHooks: function () {
        L.DomEvent.on(this._container, "touchstart", this._onTouchStart, this),
          L.DomEvent.on(this._container, "touchend", this._onTouchEnd, this),
          L.DomEvent.on(this._container, "touchmove", this._onTouchMove, this),
          this._detectIE()
            ? (L.DomEvent.on(
                this._container,
                "MSPointerDown",
                this._onTouchStart,
                this
              ),
              L.DomEvent.on(
                this._container,
                "MSPointerUp",
                this._onTouchEnd,
                this
              ),
              L.DomEvent.on(
                this._container,
                "MSPointerMove",
                this._onTouchMove,
                this
              ),
              L.DomEvent.on(
                this._container,
                "MSPointerCancel",
                this._onTouchCancel,
                this
              ))
            : (L.DomEvent.on(
                this._container,
                "touchcancel",
                this._onTouchCancel,
                this
              ),
              L.DomEvent.on(
                this._container,
                "touchleave",
                this._onTouchLeave,
                this
              ));
      },
      removeHooks: function () {
        L.DomEvent.off(this._container, "touchstart", this._onTouchStart, this),
          L.DomEvent.off(this._container, "touchend", this._onTouchEnd, this),
          L.DomEvent.off(this._container, "touchmove", this._onTouchMove, this),
          this._detectIE()
            ? (L.DomEvent.off(
                this._container,
                "MSPointerDown",
                this._onTouchStart,
                this
              ),
              L.DomEvent.off(
                this._container,
                "MSPointerUp",
                this._onTouchEnd,
                this
              ),
              L.DomEvent.off(
                this._container,
                "MSPointerMove",
                this._onTouchMove,
                this
              ),
              L.DomEvent.off(
                this._container,
                "MSPointerCancel",
                this._onTouchCancel,
                this
              ))
            : (L.DomEvent.off(
                this._container,
                "touchcancel",
                this._onTouchCancel,
                this
              ),
              L.DomEvent.off(
                this._container,
                "touchleave",
                this._onTouchLeave,
                this
              ));
      },
      _touchEvent: function (t, e) {
        var i = {};
        if (void 0 !== t.touches) {
          if (!t.touches.length) return;
          i = t.touches[0];
        } else {
          if ("touch" !== t.pointerType) return;
          if (((i = t), !this._filterClick(t))) return;
        }
        var o = this._map.mouseEventToContainerPoint(i),
          a = this._map.mouseEventToLayerPoint(i),
          n = this._map.layerPointToLatLng(a);
        this._map.fire(e, {
          latlng: n,
          layerPoint: a,
          containerPoint: o,
          pageX: i.pageX,
          pageY: i.pageY,
          originalEvent: t,
        });
      },
      _filterClick: function (t) {
        var e = t.timeStamp || t.originalEvent.timeStamp,
          i = L.DomEvent._lastClick && e - L.DomEvent._lastClick;
        return (i && i > 100 && i < 500) ||
          (t.target._simulatedClick && !t._simulated)
          ? (L.DomEvent.stop(t), !1)
          : ((L.DomEvent._lastClick = e), !0);
      },
      _onTouchStart: function (t) {
        if (this._map._loaded) {
          this._touchEvent(t, "touchstart");
        }
      },
      _onTouchEnd: function (t) {
        if (this._map._loaded) {
          this._touchEvent(t, "touchend");
        }
      },
      _onTouchCancel: function (t) {
        if (this._map._loaded) {
          var e = "touchcancel";
          this._detectIE() && (e = "pointercancel"), this._touchEvent(t, e);
        }
      },
      _onTouchLeave: function (t) {
        if (this._map._loaded) {
          this._touchEvent(t, "touchleave");
        }
      },
      _onTouchMove: function (t) {
        if (this._map._loaded) {
          this._touchEvent(t, "touchmove");
        }
      },
      _detectIE: function () {
        var e = t.navigator.userAgent,
          i = e.indexOf("MSIE ");
        if (i > 0) return parseInt(e.substring(i + 5, e.indexOf(".", i)), 10);
        if (e.indexOf("Trident/") > 0) {
          var o = e.indexOf("rv:");
          return parseInt(e.substring(o + 3, e.indexOf(".", o)), 10);
        }
        var a = e.indexOf("Edge/");
        return a > 0 && parseInt(e.substring(a + 5, e.indexOf(".", a)), 10);
      },
    })),
    L.Map.addInitHook("addHandler", "touchExtend", L.Map.TouchExtend),
    (L.Marker.Touch = L.Marker.extend({
      _initInteraction: function () {
        return this.addInteractiveTarget
          ? L.Marker.prototype._initInteraction.apply(this)
          : this._initInteractionLegacy();
      },
      _initInteractionLegacy: function () {
        if (this.options.clickable) {
          var t = this._icon,
            e = [
              "dblclick",
              "mousedown",
              "mouseover",
              "mouseout",
              "contextmenu",
              "touchstart",
              "touchend",
              "touchmove",
            ];
          this._detectIE
            ? e.concat([
                "MSPointerDown",
                "MSPointerUp",
                "MSPointerMove",
                "MSPointerCancel",
              ])
            : e.concat(["touchcancel"]),
            L.DomUtil.addClass(t, "leaflet-clickable"),
            L.DomEvent.on(t, "click", this._onMouseClick, this),
            L.DomEvent.on(t, "keypress", this._onKeyPress, this);
          for (var i = 0; i < e.length; i++)
            L.DomEvent.on(t, e[i], this._fireMouseEvent, this);
          L.Handler.MarkerDrag &&
            ((this.dragging = new L.Handler.MarkerDrag(this)),
            this.options.draggable && this.dragging.enable());
        }
      },
      _detectIE: function () {
        var e = t.navigator.userAgent,
          i = e.indexOf("MSIE ");
        if (i > 0) return parseInt(e.substring(i + 5, e.indexOf(".", i)), 10);
        if (e.indexOf("Trident/") > 0) {
          var o = e.indexOf("rv:");
          return parseInt(e.substring(o + 3, e.indexOf(".", o)), 10);
        }
        var a = e.indexOf("Edge/");
        return a > 0 && parseInt(e.substring(a + 5, e.indexOf(".", a)), 10);
      },
    })),
    (L.LatLngUtil = {
      cloneLatLngs: function (t) {
        for (var e = [], i = 0, o = t.length; i < o; i++)
          Array.isArray(t[i])
            ? e.push(L.LatLngUtil.cloneLatLngs(t[i]))
            : e.push(this.cloneLatLng(t[i]));
        return e;
      },
      cloneLatLng: function (t) {
        return L.latLng(t.lat, t.lng);
      },
    }),
    (function () {
      var t = { km: 2, ha: 2, m: 0, mi: 2, ac: 2, yd: 0, ft: 0, nm: 2 };
      L.GeometryUtil = L.extend(L.GeometryUtil || {}, {
        geodesicArea: function (t) {
          var e,
            i,
            o = t.length,
            a = 0,
            n = Math.PI / 180;
          if (o > 2) {
            for (var s = 0; s < o; s++)
              (e = t[s]),
                (i = t[(s + 1) % o]),
                (a +=
                  (i.lng - e.lng) *
                  n *
                  (2 + Math.sin(e.lat * n) + Math.sin(i.lat * n)));
            a = (6378137 * a * 6378137) / 2;
          }
          return Math.abs(a);
        },
        formattedNumber: function (t, e) {
          var i = parseFloat(t).toFixed(e),
            o = L.drawLocal.format && L.drawLocal.format.numeric,
            a = o && o.delimiters,
            n = a && a.thousands,
            s = a && a.decimal;
          if (n || s) {
            var r = i.split(".");
            (i = n ? r[0].replace(/(\d)(?=(\d{3})+(?!\d))/g, "$1" + n) : r[0]),
              (s = s || "."),
              r.length > 1 && (i = i + s + r[1]);
          }
          return i;
        },
        readableArea: function (e, i, o) {
          var a,
            n,
            o = L.Util.extend({}, t, o);
          return (
            i
              ? ((n = ["ha", "m"]),
                (type = typeof i),
                "string" === type ? (n = [i]) : "boolean" !== type && (n = i),
                (a =
                  e >= 1e6 && -1 !== n.indexOf("km")
                    ? L.GeometryUtil.formattedNumber(1e-6 * e, o.km) + " km²"
                    : e >= 1e4 && -1 !== n.indexOf("ha")
                    ? L.GeometryUtil.formattedNumber(1e-4 * e, o.ha) + " ha"
                    : L.GeometryUtil.formattedNumber(e, o.m) + " m²"))
              : ((e /= 0.836127),
                (a =
                  e >= 3097600
                    ? L.GeometryUtil.formattedNumber(e / 3097600, o.mi) + " mi²"
                    : e >= 4840
                    ? L.GeometryUtil.formattedNumber(e / 4840, o.ac) + " acres"
                    : L.GeometryUtil.formattedNumber(e, o.yd) + " yd²")),
            a
          );
        },
        readableDistance: function (e, i, o, a, n) {
          var s,
            n = L.Util.extend({}, t, n);
          switch (
            i
              ? "string" == typeof i
                ? i
                : "metric"
              : o
              ? "feet"
              : a
              ? "nauticalMile"
              : "yards"
          ) {
            case "metric":
              s =
                e > 1e3
                  ? L.GeometryUtil.formattedNumber(e / 1e3, n.km) + " km"
                  : L.GeometryUtil.formattedNumber(e, n.m) + " m";
              break;
            case "feet":
              (e *= 3.28083),
                (s = L.GeometryUtil.formattedNumber(e, n.ft) + " ft");
              break;
            case "nauticalMile":
              (e *= 0.53996),
                (s = L.GeometryUtil.formattedNumber(e / 1e3, n.nm) + " nm");
              break;
            case "yards":
            default:
              (e *= 1.09361),
                (s =
                  e > 1760
                    ? L.GeometryUtil.formattedNumber(e / 1760, n.mi) + " miles"
                    : L.GeometryUtil.formattedNumber(e, n.yd) + " yd");
          }
          return s;
        },
        isVersion07x: function () {
          var t = L.version.split(".");
          return 0 === parseInt(t[0], 10) && 7 === parseInt(t[1], 10);
        },
      });
    })(),
    L.Util.extend(L.LineUtil, {
      segmentsIntersect: function (t, e, i, o) {
        return (
          this._checkCounterclockwise(t, i, o) !==
            this._checkCounterclockwise(e, i, o) &&
          this._checkCounterclockwise(t, e, i) !==
            this._checkCounterclockwise(t, e, o)
        );
      },
      _checkCounterclockwise: function (t, e, i) {
        return (i.y - t.y) * (e.x - t.x) > (e.y - t.y) * (i.x - t.x);
      },
    }),
    L.Polyline.include({
      intersects: function () {
        var t,
          e,
          i,
          o = this._getProjectedPoints(),
          a = o ? o.length : 0;
        if (this._tooFewPointsForIntersection()) return !1;
        for (t = a - 1; t >= 3; t--)
          if (
            ((e = o[t - 1]),
            (i = o[t]),
            this._lineSegmentsIntersectsRange(e, i, t - 2))
          )
            return !0;
        return !1;
      },
      newLatLngIntersects: function (t, e) {
        return (
          !!this._map &&
          this.newPointIntersects(this._map.latLngToLayerPoint(t), e)
        );
      },
      newPointIntersects: function (t, e) {
        var i = this._getProjectedPoints(),
          o = i ? i.length : 0,
          a = i ? i[o - 1] : null,
          n = o - 2;
        return (
          !this._tooFewPointsForIntersection(1) &&
          this._lineSegmentsIntersectsRange(a, t, n, e ? 1 : 0)
        );
      },
      _tooFewPointsForIntersection: function (t) {
        var e = this._getProjectedPoints(),
          i = e ? e.length : 0;
        return (i += t || 0), !e || i <= 3;
      },
      _lineSegmentsIntersectsRange: function (t, e, i, o) {
        var a,
          n,
          s = this._getProjectedPoints();
        o = o || 0;
        for (var r = i; r > o; r--)
          if (
            ((a = s[r - 1]),
            (n = s[r]),
            L.LineUtil.segmentsIntersect(t, e, a, n))
          )
            return !0;
        return !1;
      },
      _getProjectedPoints: function () {
        if (!this._defaultShape) return this._originalPoints;
        for (var t = [], e = this._defaultShape(), i = 0; i < e.length; i++)
          t.push(this._map.latLngToLayerPoint(e[i]));
        return t;
      },
    }),
    L.Polygon.include({
      intersects: function () {
        var t,
          e,
          i,
          o,
          a = this._getProjectedPoints();
        return (
          !this._tooFewPointsForIntersection() &&
          (!!L.Polyline.prototype.intersects.call(this) ||
            ((t = a.length),
            (e = a[0]),
            (i = a[t - 1]),
            (o = t - 2),
            this._lineSegmentsIntersectsRange(i, e, o, 1)))
        );
      },
    }),
    (L.Control.Draw = L.Control.extend({
      options: { position: "topleft", draw: {}, edit: !1 },
      initialize: function (t) {
        if (L.version < "0.7")
          throw new Error(
            "Leaflet.draw 0.2.3+ requires Leaflet 0.7.0+. Download latest from https://github.com/Leaflet/Leaflet/"
          );
        L.Control.prototype.initialize.call(this, t);
        var e;
        (this._toolbars = {}),
          L.DrawToolbar &&
            this.options.draw &&
            ((e = new L.DrawToolbar(this.options.draw)),
            (this._toolbars[L.DrawToolbar.TYPE] = e),
            this._toolbars[L.DrawToolbar.TYPE].on(
              "enable",
              this._toolbarEnabled,
              this
            )),
          L.EditToolbar &&
            this.options.edit &&
            ((e = new L.EditToolbar(this.options.edit)),
            (this._toolbars[L.EditToolbar.TYPE] = e),
            this._toolbars[L.EditToolbar.TYPE].on(
              "enable",
              this._toolbarEnabled,
              this
            )),
          (L.toolbar = this);
      },
      onAdd: function (t) {
        var e,
          i = L.DomUtil.create("div", "leaflet-draw"),
          o = !1;
        for (var a in this._toolbars)
          this._toolbars.hasOwnProperty(a) &&
            (e = this._toolbars[a].addToolbar(t)) &&
            (o ||
              (L.DomUtil.hasClass(e, "leaflet-draw-toolbar-top") ||
                L.DomUtil.addClass(e.childNodes[0], "leaflet-draw-toolbar-top"),
              (o = !0)),
            i.appendChild(e));
        return i;
      },
      onRemove: function () {
        for (var t in this._toolbars)
          this._toolbars.hasOwnProperty(t) && this._toolbars[t].removeToolbar();
      },
      setDrawingOptions: function (t) {
        for (var e in this._toolbars)
          this._toolbars[e] instanceof L.DrawToolbar &&
            this._toolbars[e].setOptions(t);
      },
      _toolbarEnabled: function (t) {
        var e = t.target;
        for (var i in this._toolbars)
          this._toolbars[i] !== e && this._toolbars[i].disable();
      },
    })),
    L.Map.mergeOptions({ drawControlTooltips: !0, drawControl: !1 }),
    L.Map.addInitHook(function () {
      this.options.drawControl &&
        ((this.drawControl = new L.Control.Draw()),
        this.addControl(this.drawControl));
    }),
    (L.Toolbar = L.Class.extend({
      initialize: function (t) {
        L.setOptions(this, t),
          (this._modes = {}),
          (this._actionButtons = []),
          (this._activeMode = null);
        var e = L.version.split(".");
        1 === parseInt(e[0], 10) && parseInt(e[1], 10) >= 2
          ? L.Toolbar.include(L.Evented.prototype)
          : L.Toolbar.include(L.Mixin.Events);
      },
      enabled: function () {
        return null !== this._activeMode;
      },
      disable: function () {
        this.enabled() && this._activeMode.handler.disable();
      },
      addToolbar: function (t) {
        var e,
          i = L.DomUtil.create("div", "leaflet-draw-section"),
          o = 0,
          a = this._toolbarClass || "",
          n = this.getModeHandlers(t);
        for (
          this._toolbarContainer = L.DomUtil.create(
            "div",
            "leaflet-draw-toolbar leaflet-bar"
          ),
            this._map = t,
            e = 0;
          e < n.length;
          e++
        )
          n[e].enabled &&
            this._initModeHandler(
              n[e].handler,
              this._toolbarContainer,
              o++,
              a,
              n[e].title
            );
        if (o)
          return (
            (this._lastButtonIndex = --o),
            (this._actionsContainer = L.DomUtil.create(
              "ul",
              "leaflet-draw-actions"
            )),
            i.appendChild(this._toolbarContainer),
            i.appendChild(this._actionsContainer),
            i
          );
      },
      removeToolbar: function () {
        for (var t in this._modes)
          this._modes.hasOwnProperty(t) &&
            (this._disposeButton(
              this._modes[t].button,
              this._modes[t].handler.enable,
              this._modes[t].handler
            ),
            this._modes[t].handler.disable(),
            this._modes[t].handler
              .off("enabled", this._handlerActivated, this)
              .off("disabled", this._handlerDeactivated, this));
        this._modes = {};
        for (var e = 0, i = this._actionButtons.length; e < i; e++)
          this._disposeButton(
            this._actionButtons[e].button,
            this._actionButtons[e].callback,
            this
          );
        (this._actionButtons = []), (this._actionsContainer = null);
      },
      _initModeHandler: function (t, e, i, o, a) {
        var n = t.type;
        (this._modes[n] = {}),
          (this._modes[n].handler = t),
          (this._modes[n].button = this._createButton({
            type: n,
            title: a,
            className: o + "-" + n,
            container: e,
            callback: this._modes[n].handler.enable,
            context: this._modes[n].handler,
          })),
          (this._modes[n].buttonIndex = i),
          this._modes[n].handler
            .on("enabled", this._handlerActivated, this)
            .on("disabled", this._handlerDeactivated, this);
      },
      _detectIOS: function () {
        return /iPad|iPhone|iPod/.test(navigator.userAgent) && !t.MSStream;
      },
      _createButton: function (t) {
        var e = L.DomUtil.create("a", t.className || "", t.container),
          i = L.DomUtil.create("span", "sr-only", t.container);
        (e.href = "#"),
          e.appendChild(i),
          t.title && ((e.title = t.title), (i.innerHTML = t.title)),
          t.text && ((e.innerHTML = t.text), (i.innerHTML = t.text));
        var o = this._detectIOS() ? "touchstart" : "click";
        return (
          L.DomEvent.on(e, "click", L.DomEvent.stopPropagation)
            .on(e, "mousedown", L.DomEvent.stopPropagation)
            .on(e, "dblclick", L.DomEvent.stopPropagation)
            .on(e, "touchstart", L.DomEvent.stopPropagation)
            .on(e, "click", L.DomEvent.preventDefault)
            .on(e, o, t.callback, t.context),
          e
        );
      },
      _disposeButton: function (t, e) {
        var i = this._detectIOS() ? "touchstart" : "click";
        L.DomEvent.off(t, "click", L.DomEvent.stopPropagation)
          .off(t, "mousedown", L.DomEvent.stopPropagation)
          .off(t, "dblclick", L.DomEvent.stopPropagation)
          .off(t, "touchstart", L.DomEvent.stopPropagation)
          .off(t, "click", L.DomEvent.preventDefault)
          .off(t, i, e);
      },
      _handlerActivated: function (t) {
        this.disable(),
          (this._activeMode = this._modes[t.handler]),
          L.DomUtil.addClass(
            this._activeMode.button,
            "leaflet-draw-toolbar-button-enabled"
          ),
          this._showActionsToolbar(),
          this.fire("enable");
      },
      _handlerDeactivated: function () {
        this._hideActionsToolbar(),
          L.DomUtil.removeClass(
            this._activeMode.button,
            "leaflet-draw-toolbar-button-enabled"
          ),
          (this._activeMode = null),
          this.fire("disable");
      },
      _createActions: function (t) {
        var e,
          i,
          o,
          a,
          n = this._actionsContainer,
          s = this.getActions(t),
          r = s.length;
        for (i = 0, o = this._actionButtons.length; i < o; i++)
          this._disposeButton(
            this._actionButtons[i].button,
            this._actionButtons[i].callback
          );
        for (this._actionButtons = []; n.firstChild; )
          n.removeChild(n.firstChild);
        for (var l = 0; l < r; l++)
          ("enabled" in s[l] && !s[l].enabled) ||
            ((e = L.DomUtil.create("li", "", n)),
            (a = this._createButton({
              title: s[l].title,
              text: s[l].text,
              container: e,
              callback: s[l].callback,
              context: s[l].context,
            })),
            this._actionButtons.push({ button: a, callback: s[l].callback }));
      },
      _showActionsToolbar: function () {
        var t = this._activeMode.buttonIndex,
          e = this._lastButtonIndex,
          i = this._activeMode.button.offsetTop - 1;
        this._createActions(this._activeMode.handler),
          (this._actionsContainer.style.top = i + "px"),
          0 === t &&
            (L.DomUtil.addClass(
              this._toolbarContainer,
              "leaflet-draw-toolbar-notop"
            ),
            L.DomUtil.addClass(
              this._actionsContainer,
              "leaflet-draw-actions-top"
            )),
          t === e &&
            (L.DomUtil.addClass(
              this._toolbarContainer,
              "leaflet-draw-toolbar-nobottom"
            ),
            L.DomUtil.addClass(
              this._actionsContainer,
              "leaflet-draw-actions-bottom"
            )),
          (this._actionsContainer.style.display = "block"),
          this._map.fire(L.Draw.Event.TOOLBAROPENED);
      },
      _hideActionsToolbar: function () {
        (this._actionsContainer.style.display = "none"),
          L.DomUtil.removeClass(
            this._toolbarContainer,
            "leaflet-draw-toolbar-notop"
          ),
          L.DomUtil.removeClass(
            this._toolbarContainer,
            "leaflet-draw-toolbar-nobottom"
          ),
          L.DomUtil.removeClass(
            this._actionsContainer,
            "leaflet-draw-actions-top"
          ),
          L.DomUtil.removeClass(
            this._actionsContainer,
            "leaflet-draw-actions-bottom"
          ),
          this._map.fire(L.Draw.Event.TOOLBARCLOSED);
      },
    })),
    (L.Draw = L.Draw || {}),
    (L.Draw.Tooltip = L.Class.extend({
      initialize: function (t) {
        (this._map = t),
          (this._popupPane = t._panes.popupPane),
          (this._visible = !1),
          (this._container = t.options.drawControlTooltips
            ? L.DomUtil.create("div", "leaflet-draw-tooltip", this._popupPane)
            : null),
          (this._singleLineLabel = !1),
          this._map.on("mouseout", this._onMouseOut, this);
      },
      dispose: function () {
        this._map.off("mouseout", this._onMouseOut, this),
          this._container &&
            (this._popupPane.removeChild(this._container),
            (this._container = null));
      },
      updateContent: function (t) {
        return this._container
          ? ((t.subtext = t.subtext || ""),
            0 !== t.subtext.length || this._singleLineLabel
              ? t.subtext.length > 0 &&
                this._singleLineLabel &&
                (L.DomUtil.removeClass(
                  this._container,
                  "leaflet-draw-tooltip-single"
                ),
                (this._singleLineLabel = !1))
              : (L.DomUtil.addClass(
                  this._container,
                  "leaflet-draw-tooltip-single"
                ),
                (this._singleLineLabel = !0)),
            (this._container.innerHTML =
              (t.subtext.length > 0
                ? '<span class="leaflet-draw-tooltip-subtext">' +
                  t.subtext +
                  "</span><br />"
                : "") +
              "<span>" +
              t.text +
              "</span>"),
            t.text || t.subtext
              ? ((this._visible = !0),
                (this._container.style.visibility = "inherit"))
              : ((this._visible = !1),
                (this._container.style.visibility = "hidden")),
            this)
          : this;
      },
      updatePosition: function (t) {
        var e = this._map.latLngToLayerPoint(t),
          i = this._container;
        return (
          this._container &&
            (this._visible && (i.style.visibility = "inherit"),
            L.DomUtil.setPosition(i, e)),
          this
        );
      },
      showAsError: function () {
        return (
          this._container &&
            L.DomUtil.addClass(this._container, "leaflet-error-draw-tooltip"),
          this
        );
      },
      removeError: function () {
        return (
          this._container &&
            L.DomUtil.removeClass(
              this._container,
              "leaflet-error-draw-tooltip"
            ),
          this
        );
      },
      _onMouseOut: function () {
        this._container && (this._container.style.visibility = "hidden");
      },
    })),
    (L.DrawToolbar = L.Toolbar.extend({
      statics: { TYPE: "draw" },
      options: {
        polyline: {},
        polygon: {},
        rectangle: {},
        circle: {},
        marker: {},
        circlemarker: {},
      },
      initialize: function (t) {
        for (var e in this.options)
          this.options.hasOwnProperty(e) &&
            t[e] &&
            (t[e] = L.extend({}, this.options[e], t[e]));
        (this._toolbarClass = "leaflet-draw-draw"),
          L.Toolbar.prototype.initialize.call(this, t);
      },
      getModeHandlers: function (t) {
        return [
          {
            enabled: this.options.polyline,
            handler: new L.Draw.Polyline(t, this.options.polyline),
            title: L.drawLocal.draw.toolbar.buttons.polyline,
          },
          {
            enabled: this.options.polygon,
            handler: new L.Draw.Polygon(t, this.options.polygon),
            title: L.drawLocal.draw.toolbar.buttons.polygon,
          },
          {
            enabled: this.options.rectangle,
            handler: new L.Draw.Rectangle(t, this.options.rectangle),
            title: L.drawLocal.draw.toolbar.buttons.rectangle,
          },
          {
            enabled: this.options.circle,
            handler: new L.Draw.Circle(t, this.options.circle),
            title: L.drawLocal.draw.toolbar.buttons.circle,
          },
          {
            enabled: this.options.marker,
            handler: new L.Draw.Marker(t, this.options.marker),
            title: L.drawLocal.draw.toolbar.buttons.marker,
          },
          {
            enabled: this.options.circlemarker,
            handler: new L.Draw.CircleMarker(t, this.options.circlemarker),
            title: L.drawLocal.draw.toolbar.buttons.circlemarker,
          },
        ];
      },
      getActions: function (t) {
        return [
          {
            enabled: t.completeShape,
            title: L.drawLocal.draw.toolbar.finish.title,
            text: L.drawLocal.draw.toolbar.finish.text,
            callback: t.completeShape,
            context: t,
          },
          {
            enabled: t.deleteLastVertex,
            title: L.drawLocal.draw.toolbar.undo.title,
            text: L.drawLocal.draw.toolbar.undo.text,
            callback: t.deleteLastVertex,
            context: t,
          },
          {
            title: L.drawLocal.draw.toolbar.actions.title,
            text: L.drawLocal.draw.toolbar.actions.text,
            callback: this.disable,
            context: this,
          },
        ];
      },
      setOptions: function (t) {
        L.setOptions(this, t);
        for (var e in this._modes)
          this._modes.hasOwnProperty(e) &&
            t.hasOwnProperty(e) &&
            this._modes[e].handler.setOptions(t[e]);
      },
    })),
    (L.EditToolbar = L.Toolbar.extend({
      statics: { TYPE: "edit" },
      options: {
        edit: {
          selectedPathOptions: {
            dashArray: "10, 10",
            fill: !0,
            fillColor: "#fe57a1",
            fillOpacity: 0.1,
            maintainColor: !1,
          },
        },
        remove: {},
        poly: null,
        featureGroup: null,
      },
      initialize: function (t) {
        t.edit &&
          (void 0 === t.edit.selectedPathOptions &&
            (t.edit.selectedPathOptions =
              this.options.edit.selectedPathOptions),
          (t.edit.selectedPathOptions = L.extend(
            {},
            this.options.edit.selectedPathOptions,
            t.edit.selectedPathOptions
          ))),
          t.remove && (t.remove = L.extend({}, this.options.remove, t.remove)),
          t.poly && (t.poly = L.extend({}, this.options.poly, t.poly)),
          (this._toolbarClass = "leaflet-draw-edit"),
          L.Toolbar.prototype.initialize.call(this, t),
          (this._selectedFeatureCount = 0);
      },
      getModeHandlers: function (t) {
        var e = this.options.featureGroup;
        return [
          {
            enabled: this.options.edit,
            handler: new L.EditToolbar.Edit(t, {
              featureGroup: e,
              selectedPathOptions: this.options.edit.selectedPathOptions,
              poly: this.options.poly,
            }),
            title: L.drawLocal.edit.toolbar.buttons.edit,
          },
          {
            enabled: this.options.remove,
            handler: new L.EditToolbar.Delete(t, { featureGroup: e }),
            title: L.drawLocal.edit.toolbar.buttons.remove,
          },
        ];
      },
      getActions: function (t) {
        var e = [
          {
            title: L.drawLocal.edit.toolbar.actions.save.title,
            text: L.drawLocal.edit.toolbar.actions.save.text,
            callback: this._save,
            context: this,
          },
          {
            title: L.drawLocal.edit.toolbar.actions.cancel.title,
            text: L.drawLocal.edit.toolbar.actions.cancel.text,
            callback: this.disable,
            context: this,
          },
        ];
        return (
          t.removeAllLayers &&
            e.push({
              title: L.drawLocal.edit.toolbar.actions.clearAll.title,
              text: L.drawLocal.edit.toolbar.actions.clearAll.text,
              callback: this._clearAllLayers,
              context: this,
            }),
          e
        );
      },
      addToolbar: function (t) {
        var e = L.Toolbar.prototype.addToolbar.call(this, t);
        return (
          this._checkDisabled(),
          this.options.featureGroup.on(
            "layeradd layerremove",
            this._checkDisabled,
            this
          ),
          e
        );
      },
      removeToolbar: function () {
        this.options.featureGroup.off(
          "layeradd layerremove",
          this._checkDisabled,
          this
        ),
          L.Toolbar.prototype.removeToolbar.call(this);
      },
      disable: function () {
        this.enabled() &&
          (this._activeMode.handler.revertLayers(),
          L.Toolbar.prototype.disable.call(this));
      },
      _save: function () {
        this._activeMode.handler.save(),
          this._activeMode && this._activeMode.handler.disable();
      },
      _clearAllLayers: function () {
        this._activeMode.handler.removeAllLayers(),
          this._activeMode && this._activeMode.handler.disable();
      },
      _checkDisabled: function () {
        var t,
          e = this.options.featureGroup,
          i = 0 !== e.getLayers().length;
        this.options.edit &&
          ((t = this._modes[L.EditToolbar.Edit.TYPE].button),
          i
            ? L.DomUtil.removeClass(t, "leaflet-disabled")
            : L.DomUtil.addClass(t, "leaflet-disabled"),
          t.setAttribute(
            "title",
            i
              ? L.drawLocal.edit.toolbar.buttons.edit
              : L.drawLocal.edit.toolbar.buttons.editDisabled
          )),
          this.options.remove &&
            ((t = this._modes[L.EditToolbar.Delete.TYPE].button),
            i
              ? L.DomUtil.removeClass(t, "leaflet-disabled")
              : L.DomUtil.addClass(t, "leaflet-disabled"),
            t.setAttribute(
              "title",
              i
                ? L.drawLocal.edit.toolbar.buttons.remove
                : L.drawLocal.edit.toolbar.buttons.removeDisabled
            ));
      },
    })),
    (L.EditToolbar.Edit = L.Handler.extend({
      statics: { TYPE: "edit" },
      initialize: function (t, e) {
        if (
          (L.Handler.prototype.initialize.call(this, t),
          L.setOptions(this, e),
          (this._featureGroup = e.featureGroup),
          !(this._featureGroup instanceof L.FeatureGroup))
        )
          throw new Error("options.featureGroup must be a L.FeatureGroup");
        (this._uneditedLayerProps = {}), (this.type = L.EditToolbar.Edit.TYPE);
        var i = L.version.split(".");
        1 === parseInt(i[0], 10) && parseInt(i[1], 10) >= 2
          ? L.EditToolbar.Edit.include(L.Evented.prototype)
          : L.EditToolbar.Edit.include(L.Mixin.Events);
      },
      enable: function () {
        !this._enabled &&
          this._hasAvailableLayers() &&
          (this.fire("enabled", { handler: this.type }),
          this._map.fire(L.Draw.Event.EDITSTART, { handler: this.type }),
          L.Handler.prototype.enable.call(this),
          this._featureGroup
            .on("layeradd", this._enableLayerEdit, this)
            .on("layerremove", this._disableLayerEdit, this));
      },
      disable: function () {
        this._enabled &&
          (this._featureGroup
            .off("layeradd", this._enableLayerEdit, this)
            .off("layerremove", this._disableLayerEdit, this),
          L.Handler.prototype.disable.call(this),
          this._map.fire(L.Draw.Event.EDITSTOP, { handler: this.type }),
          this.fire("disabled", { handler: this.type }));
      },
      addHooks: function () {
        var t = this._map;
        t &&
          (t.getContainer().focus(),
          this._featureGroup.eachLayer(this._enableLayerEdit, this),
          (this._tooltip = new L.Draw.Tooltip(this._map)),
          this._tooltip.updateContent({
            text: L.drawLocal.edit.handlers.edit.tooltip.text,
            subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext,
          }),
          (t._editTooltip = this._tooltip),
          this._updateTooltip(),
          this._map
            .on("mousemove", this._onMouseMove, this)
            .on("touchmove", this._onMouseMove, this)
            .on("MSPointerMove", this._onMouseMove, this)
            .on(L.Draw.Event.EDITVERTEX, this._updateTooltip, this));
      },
      removeHooks: function () {
        this._map &&
          (this._featureGroup.eachLayer(this._disableLayerEdit, this),
          (this._uneditedLayerProps = {}),
          this._tooltip.dispose(),
          (this._tooltip = null),
          this._map
            .off("mousemove", this._onMouseMove, this)
            .off("touchmove", this._onMouseMove, this)
            .off("MSPointerMove", this._onMouseMove, this)
            .off(L.Draw.Event.EDITVERTEX, this._updateTooltip, this));
      },
      revertLayers: function () {
        this._featureGroup.eachLayer(function (t) {
          this._revertLayer(t);
        }, this);
      },
      save: function () {
        var t = new L.LayerGroup();
        this._featureGroup.eachLayer(function (e) {
          e.edited && (t.addLayer(e), (e.edited = !1));
        }),
          this._map.fire(L.Draw.Event.EDITED, { layers: t });
      },
      _backupLayer: function (t) {
        var e = L.Util.stamp(t);
        this._uneditedLayerProps[e] ||
          (t instanceof L.Polyline ||
          t instanceof L.Polygon ||
          t instanceof L.Rectangle
            ? (this._uneditedLayerProps[e] = {
                latlngs: L.LatLngUtil.cloneLatLngs(t.getLatLngs()),
              })
            : t instanceof L.Circle
            ? (this._uneditedLayerProps[e] = {
                latlng: L.LatLngUtil.cloneLatLng(t.getLatLng()),
                radius: t.getRadius(),
              })
            : (t instanceof L.Marker || t instanceof L.CircleMarker) &&
              (this._uneditedLayerProps[e] = {
                latlng: L.LatLngUtil.cloneLatLng(t.getLatLng()),
              }));
      },
      _getTooltipText: function () {
        return {
          text: L.drawLocal.edit.handlers.edit.tooltip.text,
          subtext: L.drawLocal.edit.handlers.edit.tooltip.subtext,
        };
      },
      _updateTooltip: function () {
        this._tooltip.updateContent(this._getTooltipText());
      },
      _revertLayer: function (t) {
        var e = L.Util.stamp(t);
        (t.edited = !1),
          this._uneditedLayerProps.hasOwnProperty(e) &&
            (t instanceof L.Polyline ||
            t instanceof L.Polygon ||
            t instanceof L.Rectangle
              ? t.setLatLngs(this._uneditedLayerProps[e].latlngs)
              : t instanceof L.Circle
              ? (t.setLatLng(this._uneditedLayerProps[e].latlng),
                t.setRadius(this._uneditedLayerProps[e].radius))
              : (t instanceof L.Marker || t instanceof L.CircleMarker) &&
                t.setLatLng(this._uneditedLayerProps[e].latlng),
            t.fire("revert-edited", { layer: t }));
      },
      _enableLayerEdit: function (t) {
        var e,
          i,
          o = t.layer || t.target || t;
        this._backupLayer(o),
          this.options.poly &&
            ((i = L.Util.extend({}, this.options.poly)), (o.options.poly = i)),
          this.options.selectedPathOptions &&
            ((e = L.Util.extend({}, this.options.selectedPathOptions)),
            e.maintainColor &&
              ((e.color = o.options.color),
              (e.fillColor = o.options.fillColor)),
            (o.options.original = L.extend({}, o.options)),
            (o.options.editing = e)),
          o instanceof L.Marker
            ? (o.editing && o.editing.enable(),
              o.dragging.enable(),
              o
                .on("dragend", this._onMarkerDragEnd)
                .on("touchmove", this._onTouchMove, this)
                .on("MSPointerMove", this._onTouchMove, this)
                .on("touchend", this._onMarkerDragEnd, this)
                .on("MSPointerUp", this._onMarkerDragEnd, this))
            : o.editing.enable();
      },
      _disableLayerEdit: function (t) {
        var e = t.layer || t.target || t;
        (e.edited = !1),
          e.editing && e.editing.disable(),
          delete e.options.editing,
          delete e.options.original,
          this._selectedPathOptions &&
            (e instanceof L.Marker
              ? this._toggleMarkerHighlight(e)
              : (e.setStyle(e.options.previousOptions),
                delete e.options.previousOptions)),
          e instanceof L.Marker
            ? (e.dragging.disable(),
              e
                .off("dragend", this._onMarkerDragEnd, this)
                .off("touchmove", this._onTouchMove, this)
                .off("MSPointerMove", this._onTouchMove, this)
                .off("touchend", this._onMarkerDragEnd, this)
                .off("MSPointerUp", this._onMarkerDragEnd, this))
            : e.editing.disable();
      },
      _onMouseMove: function (t) {
        this._tooltip.updatePosition(t.latlng);
      },
      _onMarkerDragEnd: function (t) {
        var e = t.target;
        (e.edited = !0), this._map.fire(L.Draw.Event.EDITMOVE, { layer: e });
      },
      _onTouchMove: function (t) {
        var e = t.originalEvent.changedTouches[0],
          i = this._map.mouseEventToLayerPoint(e),
          o = this._map.layerPointToLatLng(i);
        t.target.setLatLng(o);
      },
      _hasAvailableLayers: function () {
        return 0 !== this._featureGroup.getLayers().length;
      },
    })),
    (L.EditToolbar.Delete = L.Handler.extend({
      statics: { TYPE: "remove" },
      initialize: function (t, e) {
        if (
          (L.Handler.prototype.initialize.call(this, t),
          L.Util.setOptions(this, e),
          (this._deletableLayers = this.options.featureGroup),
          !(this._deletableLayers instanceof L.FeatureGroup))
        )
          throw new Error("options.featureGroup must be a L.FeatureGroup");
        this.type = L.EditToolbar.Delete.TYPE;
        var i = L.version.split(".");
        1 === parseInt(i[0], 10) && parseInt(i[1], 10) >= 2
          ? L.EditToolbar.Delete.include(L.Evented.prototype)
          : L.EditToolbar.Delete.include(L.Mixin.Events);
      },
      enable: function () {
        !this._enabled &&
          this._hasAvailableLayers() &&
          (this.fire("enabled", { handler: this.type }),
          this._map.fire(L.Draw.Event.DELETESTART, { handler: this.type }),
          L.Handler.prototype.enable.call(this),
          this._deletableLayers
            .on("layeradd", this._enableLayerDelete, this)
            .on("layerremove", this._disableLayerDelete, this));
      },
      disable: function () {
        this._enabled &&
          (this._deletableLayers
            .off("layeradd", this._enableLayerDelete, this)
            .off("layerremove", this._disableLayerDelete, this),
          L.Handler.prototype.disable.call(this),
          this._map.fire(L.Draw.Event.DELETESTOP, { handler: this.type }),
          this.fire("disabled", { handler: this.type }));
      },
      addHooks: function () {
        var t = this._map;
        t &&
          (t.getContainer().focus(),
          this._deletableLayers.eachLayer(this._enableLayerDelete, this),
          (this._deletedLayers = new L.LayerGroup()),
          (this._tooltip = new L.Draw.Tooltip(this._map)),
          this._tooltip.updateContent({
            text: L.drawLocal.edit.handlers.remove.tooltip.text,
          }),
          this._map.on("mousemove", this._onMouseMove, this));
      },
      removeHooks: function () {
        this._map &&
          (this._deletableLayers.eachLayer(this._disableLayerDelete, this),
          (this._deletedLayers = null),
          this._tooltip.dispose(),
          (this._tooltip = null),
          this._map.off("mousemove", this._onMouseMove, this));
      },
      revertLayers: function () {
        this._deletedLayers.eachLayer(function (t) {
          this._deletableLayers.addLayer(t),
            t.fire("revert-deleted", { layer: t });
        }, this);
      },
      save: function () {
        this._map.fire(L.Draw.Event.DELETED, { layers: this._deletedLayers });
      },
      removeAllLayers: function () {
        this._deletableLayers.eachLayer(function (t) {
          this._removeLayer({ layer: t });
        }, this),
          this.save();
      },
      _enableLayerDelete: function (t) {
        (t.layer || t.target || t).on("click", this._removeLayer, this);
      },
      _disableLayerDelete: function (t) {
        var e = t.layer || t.target || t;
        e.off("click", this._removeLayer, this),
          this._deletedLayers.removeLayer(e);
      },
      _removeLayer: function (t) {
        var e = t.layer || t.target || t;
        this._deletableLayers.removeLayer(e),
          this._deletedLayers.addLayer(e),
          e.fire("deleted");
      },
      _onMouseMove: function (t) {
        this._tooltip.updatePosition(t.latlng);
      },
      _hasAvailableLayers: function () {
        return 0 !== this._deletableLayers.getLayers().length;
      },
    }));
})(window, document);
